home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2007 December / PCWKCD1207B.iso / Blogowanie poza sfera / Flock 0.9.1.3 stable / flock-0.9.1.3.en-US.win32.exe / flock / chrome / browser.jar / content / browser / utilityOverlay.js < prev    next >
Encoding:
JavaScript  |  2006-12-05  |  13.5 KB  |  439 lines
  1. //@line 38 "/cygdrive/K/tinderbuild/src/flock/mozilla/browser/base/content/utilityOverlay.js"
  2.  
  3. /**
  4.  * Communicator Shared Utility Library
  5.  * for shared application glue for the Communicator suite of applications
  6.  **/
  7.  
  8. var goPrefWindow = 0;
  9. var gBidiUI = false;
  10.  
  11. function getBrowserURL()
  12. {
  13.   return "chrome://browser/content/browser.xul";
  14. }
  15.  
  16. function goToggleToolbar( id, elementID )
  17. {
  18.   var toolbar = document.getElementById(id);
  19.   var element = document.getElementById(elementID);
  20.   if (toolbar)
  21.   {
  22.     var isHidden = toolbar.hidden;
  23.     toolbar.hidden = !isHidden;
  24.     document.persist(id, 'hidden');
  25.     if (element) {
  26.       element.setAttribute("checked", isHidden ? "true" : "false");
  27.       document.persist(elementID, 'checked');
  28.     }
  29.   }
  30. }
  31.  
  32. function getTopWin()
  33. {
  34.   var windowManager = Components.classes['@mozilla.org/appshell/window-mediator;1']
  35.                                 .getService(Components.interfaces.nsIWindowMediator);
  36.   return windowManager.getMostRecentWindow("navigator:browser");
  37. }
  38.  
  39. function openTopWin( url )
  40. {
  41.   openUILink(url, {})
  42. }
  43.  
  44. function getBoolPref ( prefname, def )
  45. {
  46.   try { 
  47.     var pref = Components.classes["@mozilla.org/preferences-service;1"]
  48.                        .getService(Components.interfaces.nsIPrefBranch);
  49.     return pref.getBoolPref(prefname);
  50.   }
  51.   catch(er) {
  52.     return def;
  53.   }
  54. }
  55.  
  56. // openUILink handles clicks on UI elements that cause URLs to load.
  57. function openUILink( url, e, ignoreButton, ignoreAlt, allowKeywordFixup, postData )
  58. {
  59.   var where = whereToOpenLink(e, ignoreButton, ignoreAlt);
  60.   openUILinkIn(url, where, allowKeywordFixup, postData);
  61. }
  62.  
  63.  
  64. /* whereToOpenLink() looks at an event to decide where to open a link.
  65.  *
  66.  * The event may be a mouse event (click, double-click, middle-click) or keypress event (enter).
  67.  *
  68.  * On Windows, the modifiers are:
  69.  * Ctrl        new tab, selected
  70.  * Shift       new window
  71.  * Ctrl+Shift  new tab, in background
  72.  * Alt         save
  73.  *
  74.  * You can swap Ctrl and Ctrl+shift by toggling the hidden pref
  75.  * browser.tabs.loadBookmarksInBackground (not browser.tabs.loadInBackground, which
  76.  * is for content area links).
  77.  *
  78.  * Middle-clicking is the same as Ctrl+clicking (it opens a new tab) and it is
  79.  * subject to the shift modifier and pref in the same way.
  80.  *
  81.  * Exceptions: 
  82.  * - Alt is ignored for menu items selected using the keyboard so you don't accidentally save stuff.  
  83.  *    (Currently, the Alt isn't sent here at all for menu items, but that will change in bug 126189.)
  84.  * - Alt is hard to use in context menus, because pressing Alt closes the menu.
  85.  * - Alt can't be used on the bookmarks toolbar because Alt is used for "treat this as something draggable".
  86.  * - The button is ignored for the middle-click-paste-URL feature, since it's always a middle-click.
  87.  */
  88. function whereToOpenLink( e, ignoreButton, ignoreAlt )
  89. {
  90.   if (!e)
  91.     e = { shiftKey:false, ctrlKey:false, metaKey:false, altKey:false, button:0 };
  92.  
  93.   var shift = e.shiftKey;
  94.   var ctrl =  e.ctrlKey;
  95.   var meta =  e.metaKey;
  96.   var alt  =  e.altKey && !ignoreAlt;
  97.  
  98.   // ignoreButton allows "middle-click paste" to use function without always opening in a new window.
  99.   var middle = !ignoreButton && e.button == 1;
  100.   var middleUsesTabs = getBoolPref("browser.tabs.opentabfor.middleclick", true);
  101.  
  102.   // Don't do anything special with right-mouse clicks.  They're probably clicks on context menu items.
  103.  
  104. //@line 143 "/cygdrive/K/tinderbuild/src/flock/mozilla/browser/base/content/utilityOverlay.js"
  105.   if (ctrl || (middle && middleUsesTabs)) {
  106. //@line 145 "/cygdrive/K/tinderbuild/src/flock/mozilla/browser/base/content/utilityOverlay.js"
  107.     if (shift)
  108.       return "tabshifted";
  109.     else
  110.       return "tab";
  111.   }
  112.   else if (alt) {
  113.     return "save";
  114.   }
  115.   else if (shift || (middle && !middleUsesTabs)) {
  116.     return "window";
  117.   }
  118.   else {
  119.     return "current";
  120.   }
  121. }
  122.  
  123. /* openUILinkIn opens a URL in a place specified by the parameter |where|.
  124.  *
  125.  * |where| can be:
  126.  *  "current"     current tab            (if there aren't any browser windows, then in a new window instead)
  127.  *  "tab"         new tab                (if there aren't any browser windows, then in a new window instead)
  128.  *  "tabshifted"  same as "tab" but in background if default is to select new tabs, and vice versa
  129.  *  "window"      new window
  130.  *  "save"        save to disk (with no filename hint!)
  131.  *
  132.  * allowThirdPartyFixup controls whether third party services such as Google's
  133.  * I Feel Lucky are allowed to interpret this URL. This parameter may be
  134.  * undefined, which is treated as false.
  135.  */
  136. function openUILinkIn( url, where, allowThirdPartyFixup, postData )
  137. {
  138.   if (!where || !url)
  139.     return;
  140.  
  141.   if (where == "save") {
  142.     saveURL(url, null, null, true);
  143.     return;
  144.   }
  145.  
  146.   var w = getTopWin();
  147.  
  148.   if (!w || where == "window") {
  149.     openDialog(getBrowserURL(), "_blank", "chrome,all,dialog=no", url,
  150.                null, null, postData, allowThirdPartyFixup);
  151.     return;
  152.   }
  153.  
  154.   var loadInBackground = getBoolPref("browser.tabs.loadBookmarksInBackground", false);
  155.  
  156.   switch (where) {
  157.   case "current":
  158.     w.loadURI(url, null, postData, allowThirdPartyFixup);
  159.     w.content.focus();
  160.     break;
  161.   case "tabshifted":
  162.     loadInBackground = !loadInBackground;
  163.     // fall through
  164.   case "tab":
  165.     var browser = w.getBrowser();
  166.     browser.loadOneTab(url, null, null, postData, loadInBackground,
  167.                        allowThirdPartyFixup || false);
  168.     break;
  169.   }
  170. }
  171.  
  172. // Used as an onclick handler for UI elements with link-like behavior.
  173. // e.g. onclick="checkForMiddleClick(this, event);"
  174. function checkForMiddleClick(node, event)
  175. {
  176.   // We should be using the disabled property here instead of the attribute,
  177.   // but some elements that this function is used with don't support it (e.g.
  178.   // menuitem).
  179.   if (node.getAttribute("disabled") == "true")
  180.     return; // Do nothing
  181.  
  182.   if (event.button == 1) {
  183.     /* Execute the node's oncommand.
  184.      *
  185.      * XXX: we should use node.oncommand(event) once bug 246720 is fixed.
  186.      */
  187.     var fn = new Function("event", node.getAttribute("oncommand"));
  188.     fn.call(node, event);
  189.  
  190.     // If the middle-click was on part of a menu, close the menu.
  191.     // (Menus close automatically with left-click but not with middle-click.)
  192.     closeMenus(event.target);
  193.   }
  194. }
  195.  
  196. // Closes all popups that are ancestors of the node.
  197. function closeMenus(node)
  198. {
  199.   if ("tagName" in node) {
  200.     if (node.namespaceURI == "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
  201.     && (node.tagName == "menupopup" || node.tagName == "popup"))
  202.       node.hidePopup();
  203.  
  204.     closeMenus(node.parentNode);
  205.   }
  206. }
  207.  
  208. // update menu items that rely on focus
  209. function goUpdateGlobalEditMenuItems()
  210. {
  211.   goUpdateCommand('cmd_undo');
  212.   goUpdateCommand('cmd_redo');
  213.   goUpdateCommand('cmd_cut');
  214.   goUpdateCommand('cmd_copy');
  215.   goUpdateCommand('cmd_paste');
  216.   goUpdateCommand('cmd_selectAll');
  217.   goUpdateCommand('cmd_delete');
  218.   if (gBidiUI)
  219.     goUpdateCommand('cmd_switchTextDirection');
  220. }
  221.  
  222. // update menu items that rely on the current selection
  223. function goUpdateSelectEditMenuItems()
  224. {
  225.   goUpdateCommand('cmd_cut');
  226.   goUpdateCommand('cmd_copy');
  227.   goUpdateCommand('cmd_delete');
  228.   goUpdateCommand('cmd_selectAll');
  229. }
  230.  
  231. // update menu items that relate to undo/redo
  232. function goUpdateUndoEditMenuItems()
  233. {
  234.   goUpdateCommand('cmd_undo');
  235.   goUpdateCommand('cmd_redo');
  236. }
  237.  
  238. // update menu items that depend on clipboard contents
  239. function goUpdatePasteMenuItems()
  240. {
  241.   goUpdateCommand('cmd_paste');
  242. }
  243.  
  244. // Gather all descendent text under given document node.
  245. function gatherTextUnder ( root ) 
  246. {
  247.   var text = "";
  248.   var node = root.firstChild;
  249.   var depth = 1;
  250.   while ( node && depth > 0 ) {
  251.     // See if this node is text.
  252.     if ( node.nodeType == Node.TEXT_NODE ) {
  253.       // Add this text to our collection.
  254.       text += " " + node.data;
  255.     } else if ( node instanceof HTMLImageElement) {
  256.       // If it has an alt= attribute, use that.
  257.       var altText = node.getAttribute( "alt" );
  258.       if ( altText && altText != "" ) {
  259.         text = altText;
  260.         break;
  261.       }
  262.     }
  263.     // Find next node to test.
  264.     // First, see if this node has children.
  265.     if ( node.hasChildNodes() ) {
  266.       // Go to first child.
  267.       node = node.firstChild;
  268.       depth++;
  269.     } else {
  270.       // No children, try next sibling.
  271.       if ( node.nextSibling ) {
  272.         node = node.nextSibling;
  273.       } else {
  274.         // Last resort is our next oldest uncle/aunt.
  275.         node = node.parentNode.nextSibling;
  276.         depth--;
  277.       }
  278.     }
  279.   }
  280.   // Strip leading whitespace.
  281.   text = text.replace( /^\s+/, "" );
  282.   // Strip trailing whitespace.
  283.   text = text.replace( /\s+$/, "" );
  284.   // Compress remaining whitespace.
  285.   text = text.replace( /\s+/g, " " );
  286.   return text;
  287. }
  288.  
  289. function getShellService()
  290. {
  291.   var shell = null;
  292.   try {
  293.     shell = Components.classes["@mozilla.org/browser/shell-service;1"]
  294.       .getService(Components.interfaces.nsIShellService);
  295.   } catch (e) {dump("*** e = " + e + "\n");}
  296.   return shell;
  297. }
  298.  
  299. function isBidiEnabled() {
  300.   var rv = false;
  301.  
  302.   try {
  303.     var localeService = Components.classes["@mozilla.org/intl/nslocaleservice;1"]
  304.                                   .getService(Components.interfaces.nsILocaleService);
  305.     var systemLocale = localeService.getSystemLocale().getCategory("NSILOCALE_CTYPE").substr(0,3);
  306.  
  307.     switch (systemLocale) {
  308.       case "ar-":
  309.       case "he-":
  310.       case "fa-":
  311.       case "ur-":
  312.       case "syr":
  313.         rv = true;
  314.     }
  315.   } catch (e) {}
  316.  
  317.   // check the overriding pref
  318.   if (!rv)
  319.     rv = getBoolPref("bidi.browser.ui");
  320.  
  321.   return rv;
  322. }
  323.  
  324. function openAboutDialog()
  325. {
  326. //@line 377 "/cygdrive/K/tinderbuild/src/flock/mozilla/browser/base/content/utilityOverlay.js"
  327.   window.openDialog("chrome://browser/content/aboutDialog.xul", "About", "modal,centerscreen,chrome,resizable=no");
  328. //@line 379 "/cygdrive/K/tinderbuild/src/flock/mozilla/browser/base/content/utilityOverlay.js"
  329. }
  330.  
  331. function openPreferences(paneID)
  332. {
  333.   var instantApply = getBoolPref("browser.preferences.instantApply", false);
  334.   var features = "chrome,titlebar,toolbar,centerscreen" + (instantApply ? ",dialog=no" : ",modal");
  335.  
  336.   var wm = Components.classes["@mozilla.org/appshell/window-mediator;1"]
  337.                      .getService(Components.interfaces.nsIWindowMediator);
  338.   var win = wm.getMostRecentWindow("Browser:Preferences");
  339.   if (win) {
  340.     win.focus();
  341.     if (paneID) {
  342.       var pane = win.document.getElementById(paneID);
  343.       win.document.documentElement.showPane(pane);
  344.     }
  345.   }
  346.   else
  347.     openDialog("chrome://browser/content/preferences/preferences.xul",
  348.                "Preferences", features, paneID);
  349. }
  350.  
  351. /**
  352.  * Opens the release notes page for this version of the application.
  353.  * @param   event
  354.  *          The DOM Event that caused this function to be called, used to
  355.  *          determine where the release notes page should be displayed based
  356.  *          on modifiers (e.g. Ctrl = new tab)
  357.  */
  358. function openReleaseNotes(event)
  359. {
  360.   var formatter = Components.classes["@mozilla.org/toolkit/URLFormatterService;1"]
  361.                             .getService(Components.interfaces.nsIURLFormatter);
  362.   var relnotesURL = formatter.formatURLPref("app.releaseNotesURL");
  363.   
  364.   openUILink(relnotesURL, event, false, true);
  365. }
  366.   
  367. /**
  368.  * Opens the update manager and checks for updates to the application.
  369.  */
  370. function checkForUpdates()
  371. {
  372.   var um = 
  373.       Components.classes["@mozilla.org/updates/update-manager;1"].
  374.       getService(Components.interfaces.nsIUpdateManager);
  375.   var prompter = 
  376.       Components.classes["@mozilla.org/updates/update-prompt;1"].
  377.       createInstance(Components.interfaces.nsIUpdatePrompt);
  378.  
  379.   // If there's an update ready to be applied, show the "Update Downloaded"
  380.   // UI instead and let the user know they have to restart the browser for
  381.   // the changes to be applied. 
  382.   if (um.activeUpdate && um.activeUpdate.state == "pending")
  383.     prompter.showUpdateDownloaded(um.activeUpdate);
  384.   else
  385.     prompter.checkForUpdates();
  386. }
  387.  
  388. function buildHelpMenu()
  389. {
  390.   var updates = 
  391.       Components.classes["@mozilla.org/updates/update-service;1"].
  392.       getService(Components.interfaces.nsIApplicationUpdateService);
  393.   var um = 
  394.       Components.classes["@mozilla.org/updates/update-manager;1"].
  395.       getService(Components.interfaces.nsIUpdateManager);
  396.  
  397.   // Disable the UI if the update enabled pref has been locked by the 
  398.   // administrator or if we cannot update for some other reason
  399.   var checkForUpdates = document.getElementById("checkForUpdates");
  400.   var canUpdate = updates.canUpdate;
  401.   checkForUpdates.setAttribute("disabled", !canUpdate);
  402.   if (!canUpdate)
  403.     return; 
  404.  
  405.   var strings = document.getElementById("bundle_browser");
  406.   var activeUpdate = um.activeUpdate;
  407.   
  408.   // If there's an active update, substitute its name into the label
  409.   // we show for this item, otherwise display a generic label.
  410.   function getStringWithUpdateName(key) {
  411.     if (activeUpdate && activeUpdate.name)
  412.       return strings.getFormattedString(key, [activeUpdate.name]);
  413.     return strings.getString(key + "Fallback");
  414.   }
  415.   
  416.   // By default, show "Check for Updates..."
  417.   var key = "default";
  418.   if (activeUpdate) {
  419.     switch (activeUpdate.state) {
  420.     case "downloading":
  421.       // If we're downloading an update at present, show the text:
  422.       // "Downloading Firefox x.x..." otherwise we're paused, and show
  423.       // "Resume Downloading Firefox x.x..."
  424.       key = updates.isDownloading ? "downloading" : "resume";
  425.       break;
  426.     case "pending":
  427.       // If we're waiting for the user to restart, show: "Apply Downloaded
  428.       // Updates Now..."
  429.       key = "pending";
  430.       break;
  431.     }
  432.   }
  433.   checkForUpdates.label = getStringWithUpdateName("updatesItem_" + key);
  434.   if (um.activeUpdate && updates.isDownloading)
  435.     checkForUpdates.setAttribute("loading", "true");
  436.   else
  437.     checkForUpdates.removeAttribute("loading");
  438. }
  439.